﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Draughts
{
    class Program
    {
        /*static void Main(string[] args)
        {
            если обязан бить
                где больше шашек заберет там и бьет (нужно учесть, что для дамки это считается иначе)
            иначе 
               если нет ходов так чтобы не отдать шашку
                   ходит тем ходом который теряет как можно меньше шашек
               иначе
                   если может ходить шашкой на максимальном удалении от начала ходит ей
                       иначе
                           ходит самой ближней из тех что может  
            
            }*/

        public int[,] board = new int[10, 10];

        public int[,] getInitialBoard()
        {
            int[,] initialBoard = new int[10, 10] {
                    {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
                    {-1,0,3,0,3,0,3,0,3,-1},
                    {-1,3,0,3,0,3,0,3,0,-1},
                    {-1,0,3,0,3,0,3,0,3,-1},
                    {-1,0,0,0,0,0,0,0,0,-1},
                    {-1,0,0,0,0,0,0,0,0,-1},
                    {-1,0,1,0,1,0,1,0,1,-1},
                    {-1,1,0,1,0,1,0,1,0,-1},
                    {-1,0,1,0,1,0,1,0,1,-1},
                    {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}
                };
            return initialBoard;
        }

        public bool isKing(int x, int y)
        {
            return (board[x, y] == 2 || board[x, y] == 4);
        }

        public bool isWhite(int x, int y)
        {
            return (board[x, y] == 1 || board[x, y] == 2);
        }

        public bool isBlack(int x, int y)
        {
            return (board[x, y] == 3 || board[x, y] == 4);
        }

        public bool isEmpty(int x, int y)
        {
            return (board[x, y] == 0);
        }

        public bool isMine(int x, int y)
        {
            return (flag && isWhite(x, y)) || (!flag && isBlack(x, y));
        }

        public bool draughtCanMakeNotAttackMove(int x, int y)
        {
            bool mark = false;
            if (isKing(x, y))
            {
                int checker = 0;
                int i = 1;
                while (isEmpty(x + i, y + i))
                {
                    checker++;
                    i++;
                }
                i = 1;
                while (isEmpty(x + i, y - i))
                {
                    checker++;
                    i++;
                }
                i = 1;
                while (isEmpty(x - i, y + i))
                {
                    checker++;
                    i++;
                }
                i = 1;
                while (isEmpty(x - i, y - i))
                {
                    checker++;
                    i++;
                }
                i = 1;
                if (checker > 0)
                    mark = true;
            }
            else
            {
                if (isWhite(x, y))
                {
                    if (isEmpty(x + 1, y + 1) || isEmpty(x - 1, y + 1))
                        mark = true;
                }
                else if (isBlack(x, y))
                {
                    if (isEmpty(x + 1, y - 1) || isEmpty(x - 1, y - 1))
                        mark = true;
                }
            }
            return mark;
        }

        public void swap(int x0, int y0, int x1, int y1) 
        {
            int check = board[x0, y0];
            board[x1, y1] = check;
            board[x0, y0] = 0;
        }

        public void makeNotAttackMove(int x0, int y0, int x1, int y1)
        {
            if (draughtCanMakeNotAttackMove(x0, y0))
                swap(x0, y0, x1, y1);
        }

        public void makeAttackMove(int x0, int y0, int x1, int y1)
        {
            if (draughtMustAttack(x0, y0))
            {
                if (isKing(x0, y0)) 
                {
                    int k = x1 - x0;
                    if (k < 0) 
                        k = -k;
                    int counterMine = 0;
                    int counterEmpty = 0;
                    int counterNotMine = 0;
                    int x2 = -1;
                    int y2 = -1;
                    if (x1 > x0 && y1 > y0) 
                    {
                        for (int i = 0; i < k; i++)
                        {
                            if (!isMine(x0 + i, y0 + i))
                                counterNotMine++;
                            x2 = x0 + i;
                            y2 = y0 + i;
                            if (isMine(x0 + i, y0 + i))
                                counterMine++;
                            if (isEmpty(x0 + i, y0 + i))
                                counterEmpty++;
                        }
                    }
                    if (x1 > x0 && y1 < y0) 
                    {
                        for (int i = 0; i < k; i++)
                        {
                            if (!isMine(x0 + i, y0 - i))
                                counterNotMine++;
                            x2 = x0 + i;
                            y2 = y0 - i;
                            if (isMine(x0 + i, y0 - i))
                                counterMine++;
                            if (isEmpty(x0 + i, y0 - i))
                                counterEmpty++;
                        }
                    }
                    if (x1 < x0 && y1 > y0) 
                    {
                        for (int i = 0; i < k; i++)
                        {
                            if (!isMine(x0 - i, y0 + i))
                                counterNotMine++;
                            x2 = x0 - i;
                            y2 = y0 + i;
                            if (isMine(x0 - i, y0 + i))
                                counterMine++;
                            if (isEmpty(x0 - i, y0 + i))
                                counterEmpty++;
                        }
                    }
                    if (x1 < x0 && y1 < y0) 
                    {
                        for (int i = 0; i < k; i++)
                        {
                            if (!isMine(x0 - i, y0 - i))
                                counterNotMine++;
                            x2 = x0 - i;
                            y2 = y0 - i;
                            if (isMine(x0 - i, y0 - i))
                                counterMine++;
                            if (isEmpty(x0 - i, y0 - i))
                                counterEmpty++;
                        }
                    }
                    if (counterNotMine == 1 && counterMine == 0 && counterEmpty == k - 1)
                    {
                        swap(x0, y0, x1, y1);
                        board[x2, y2] = 0;
                    }
                }
                else
                {
                    swap(x0, y0, x1, y1);
                    board[(x0 + x1) / 2, (y0 + y1) / 2] = 0; 
                }
            }
        }

        public bool draughtMustAttack(int x, int y)
        {
            bool mark = false;
            if (isKing(x, y))
            {
                int i = 1;
                while (isEmpty(x + i, y + i))
                    i++;
                if (!isMine(x + i + 1, y + i + 1) && isEmpty(x + i + 2, y + i + 2))
                    mark = true;
                i = 1;
                while (isEmpty(x + i, y - i))
                    i++;
                if (!isMine(x + i + 1, y - i - 1) && isEmpty(x + i + 2, y - i - 2))
                    mark = true;
                i = 1;
                while (isEmpty(x - i, y + i))
                    i++;
                if (!isMine(x - i - 1, y + i + 1) && isEmpty(x - i - 2, y + i + 2))
                    mark = true;
                i = 1;
                while (isEmpty(x - i, y - i))
                    i++;
                if (!isMine(x - i - 1, y - i - 1) && isEmpty(x - i - 2, y - i - 2))
                    mark = true;
            }
            else
            {
            if ((isEmpty(x + 2, y + 2) && !isMine(x + 1, y + 1)) || (isEmpty(x - 2, y + 2) && !isMine(x - 1, y + 1)) ||
                (isEmpty(x + 2, y - 2) && !isMine(x + 1, y - 1)) || (isEmpty(x - 2, y - 2) && !isMine(x - 1, y - 1)))
                mark = true;
            }
            return mark;
        }

        public bool playerCanMakeNotAttackMove() 
        {
            bool mark = false;
            for (int j = 0; j < 10; j++)
            {
                for (int k = 0; k < 10; k++)
                {
                    if (isMine(j, k) && draughtCanMakeNotAttackMove(j, k))
                        mark = true;
                }
            }
            return mark;
        }

        public bool playerMustAttack() 
        {
            bool mark = false;
            for (int j = 0; j < 10; j++)
            {
                for (int k = 0; k < 10; k++)
                {
                    if (isMine(j, k) && draughtMustAttack(j, k))
                        mark = true;
                }
            }
            return mark;
        }

        public bool draughtCanMakeSafeMove(int x, int y) // не атакуя и не подставляясь
        {
            bool check = false;
            if (isWhite(x, y))
                check = true;
            bool mark = false;
            if (!draughtMustAttack(x, y)) 
            {
                if (draughtCanMakeNotAttackMove(x, y)) 
                {
                    if (check)
                        check = false;
                    else
                        check = true;
                    if (!playerMustAttack())
                        mark = true;
                }
            }
            return mark;
        }

        public bool playerCanMakeSafeMove()
        { 
            bool mark = false;
            for (int j = 0; j < 10; j++)
            {
                for (int k = 0; k < 10; k++)
                {
                    if (isMine(j, k) && draughtCanMakeSafeMove(j, k))
                        mark = true;
                }
            }
            return mark;
        }

        public bool draughtCanMakeMove(int x, int y) 
        {
            return (draughtMustAttack(x, y) || draughtCanMakeNotAttackMove(x, y));
        }

        public bool playerCanMakeMove() 
        {
            bool mark = false;
            for (int j = 0; j < 10; j++)
            {
                for (int k = 0; k < 10; k++)
                {
                    if (isMine(j, k) && draughtCanMakeMove(j, k))
                        mark = true;
                }
            }
            return mark;
        }

        public int countWhiteDraughts()
        {
            int result = 0;
            for (int i = 0; i < 10; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    if (isWhite(i, j))
                        result++;
                }
            }
            return result;
        }

        public int countBlackDraughts()
        {
            int result = 0;
            for (int i = 0; i < 10; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    if (isBlack(i, j))
                        result++;
                }
            }
            return result;
        }

        public bool gameIsOver()
        {
            return (countWhiteDraughts() * countBlackDraughts() == 0);
        }

        public bool isDraw()
        {
            return (!playerCanMakeMove());
        }

        public int knowWinner()
        { // 0 - игра продолжается, 1 - белые выиграли, 2 - черные
            int checker = -1;
            if (gameIsOver())
            {
                if (countWhiteDraughts() == 0)
                    checker = 2;
                if (countBlackDraughts() == 0)
                    checker = 1;
            }
            else
                checker = 0;
            return checker;
        }
    }

    public bool flag; // true - белые ходят, false - черные
}
